/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.apache.easyant.tasks;
import java.io.File;
import org.apache.easyant.core.EasyAntMagicNames;
import org.apache.ivy.core.LogOptions;
import org.apache.ivy.core.module.id.ModuleId;
import org.apache.ivy.core.module.id.ModuleRevisionId;
import org.apache.ivy.core.report.ArtifactDownloadReport;
import org.apache.ivy.core.report.ResolveReport;
import org.apache.ivy.core.resolve.ResolveOptions;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.ImportTask;
import org.apache.tools.ant.types.Path;
/**
* This abstract task is used to include / import modules.
*
* The include mechanism is similar to the current import task, excepts that it automatically prefix all targets of the
* used build module (=ant script). The prefix used by default is the name of the imported project, but it can be
* overriden when calling "include".
*
* Include is useful to use features provided by a build module, while preserving a namespace isolation to avoid names
* collisions.
*
* While possible, overriding a target defined in a included module is not recommended. To do so, the import mechanism
* is preferred.
*
*/
public abstract class AbstractImport extends AbstractEasyAntTask {
private String as;
private String mode;
private boolean mandatory;
private String buildConfigurations;
private String mainConf = "default";
private String providedConf = "provided";
private boolean changing = false;
public AbstractImport() {
super();
}
/**
* Import a module
*
* @param moduleRevisionId
* {@link ModuleRevisionId} of main artifact
* @param report
* a resolved report of the module to import
*/
protected void importModule(ModuleRevisionId moduleRevisionId, ResolveReport report) {
// Check dependency on core
checkCoreCompliance(report, providedConf);
Path path = createModulePath(moduleRevisionId.getModuleId());
File antFile = null;
for (int j = 0; j < report.getConfigurationReport(mainConf).getAllArtifactsReports().length; j++) {
ArtifactDownloadReport artifact = report.getConfigurationReport(mainConf).getAllArtifactsReports()[j];
if ("ant".equals(artifact.getType())) {
antFile = artifact.getLocalFile();
} else if (shouldBeAddedToClasspath(artifact)) {
path.createPathElement().setLocation(artifact.getLocalFile());
} else {
handleOtherResourceFile(moduleRevisionId, artifact.getName(), artifact.getExt(),
artifact.getLocalFile());
}
}
// effective import should be executed AFTER any other resource files has been handled
if (antFile != null && antFile.exists()) {
doEffectiveImport(antFile);
}
}
public boolean shouldBeAddedToClasspath(ArtifactDownloadReport artifact) {
String[] types;
if (getProject().getProperty(EasyAntMagicNames.IMPORT_CLASSPATH_TYPES) != null) {
types = getProject().getProperty(EasyAntMagicNames.IMPORT_CLASSPATH_TYPES).split(",");
} else {
types = new String[] { "jar", "bundle" };
}
for (String type : types) {
if (artifact.getType().equals(type)) {
return true;
}
}
return false;
}
/**
* Do effective import of a given ant file
*
* @param antFile
* a given ant file
*/
protected void doEffectiveImport(File antFile) {
ImportTask importTask = new ImportTask();
importTask.setFile(antFile.getAbsolutePath());
if (as != null) {
importTask.setAs(as);
importTask.setPrefixSeparator("");
}
if (mode != null && "include".equals(mode)) {
importTask.setTaskType(getMode());
}
initTask(importTask).execute();
}
/**
* <p>
* Register all location of other resource file in properties.
* </p>
* <p>
* Properties are composed with the following syntax : [organisation].[module].[artifact].[type].file
* </p>
* <p>
* The '.artifact' is optional when module name and artifact name are the same. [organisation].[module].[type].file
* </p>
*
* @param moduleRevisionId
* a {@link ModuleRevisionId} of the main artifact
* @param artifactName
* artifact name
* @param artifactExtension
* artifact extension name
* @param localResourceFile
*/
protected void handleOtherResourceFile(ModuleRevisionId moduleRevisionId, String artifactName,
String artifactExtension, File localResourceFile) {
if (localResourceFile == null) {
getProject().log(
"Can't find artifact " + artifactName + " ext" + artifactExtension
+ ". See resolution report to have details", Project.MSG_WARN);
} else {
StringBuilder sb = new StringBuilder();
sb.append(moduleRevisionId.getOrganisation());
sb.append("#");
sb.append(moduleRevisionId.getName());
sb.append(".");
if (!moduleRevisionId.getName().equals(artifactName)) {
sb.append(artifactName);
sb.append(".");
}
sb.append(artifactExtension);
sb.append(".file");
getProject().log(
"registering location of artifact " + artifactName + " ext" + artifactExtension + " on "
+ sb.toString(), Project.MSG_DEBUG);
getProject().setNewProperty(sb.toString(), localResourceFile.getAbsolutePath());
}
}
/**
* creates a classpath specific for each module, this classpath will contains all the required dependency .jars. The
* classpath is named [organisation]#[module].classpath
*
* @param moduleId
* @return
*/
protected Path createModulePath(ModuleId moduleId) {
Path path = new Path(getProject());
getProject().addReference(moduleId.toString() + ".classpath", path);
return path;
}
/**
* Configures resolve options
*
* @return configured resolveOptions
*/
protected ResolveOptions configureResolveOptions() {
// Here we do not specify explicit configuration to resolve as
// we want to check multiple configurations.
// If we make specify explicitly configurations to resolve, the
// resolution could through exceptions when configuration does
// not exist in resolved modules.
// resolveOptions.setConfs(new String[] { mainConf,providedConf });
// By default we consider that main conf is default.
// To verify core compliance we can have a dependency on
// easyant-core in a specific configuration.
// By default this configuration is provided.
// An error can be thrown if module contains non-public configurations.
ResolveOptions resolveOptions = new ResolveOptions();
resolveOptions.setLog(getResolveLog());
Boolean offline = Boolean.valueOf(getProject().getProperty(EasyAntMagicNames.EASYANT_OFFLINE));
resolveOptions.setUseCacheOnly(offline);
return resolveOptions;
}
/**
* Check dependency on easyant core with a given configuration. If dependency is found we'll check compliance with
* current core version. It uses {@link CoreRevisionCheckerTask} internally.
*
* @param report
* a {@link ResolveReport}
* @param confToCheck
* configuration to check
*/
protected void checkCoreCompliance(ResolveReport report, String confToCheck) {
if (report.getConfigurationReport(confToCheck) != null) {
log("checking module's provided dependencies ...", Project.MSG_DEBUG);
for (Object o : report.getConfigurationReport(confToCheck).getModuleRevisionIds()) {
ModuleRevisionId currentmrid = (ModuleRevisionId) o;
log("checking " + currentmrid.toString(), Project.MSG_DEBUG);
if (currentmrid.getOrganisation().equals("org.apache.easyant")
&& currentmrid.getName().equals("easyant-core")) {
CoreRevisionCheckerTask checker = new CoreRevisionCheckerTask();
checker.setRequiredRevision(currentmrid.getRevision());
initTask(checker).execute();
}
}
}
}
public void setDynamicAttribute(String attributeName, String value) throws BuildException {
PropertyTask property = new PropertyTask();
property.setName(attributeName);
property.setValue(value);
initTask(property).execute();
}
/**
* Get resolve log settings
*
* @return a string representing the log strategy
*/
protected String getResolveLog() {
String downloadLog = getProject().getProperty(EasyAntMagicNames.MODULE_DOWNLOAD_LOG);
return downloadLog != null ? downloadLog : LogOptions.LOG_DOWNLOAD_ONLY;
}
/**
* Get the alias name
*
* @return a string that represents the alias name
*/
public String getAs() {
return as;
}
/**
* Set the alias name
*
* @param as
* a string that represents the alias name
*/
public void setAs(String as) {
this.as = as;
}
/**
* Get the import mode
*
* @return a string that represents the import mode (e.g. import / include)
*/
public String getMode() {
return mode;
}
/**
* Set the import mode
*
* @param mode
* a string that represents the import mode (e.g. import / include)
*/
public void setMode(String mode) {
this.mode = mode;
}
public String getBuildConfigurations() {
return buildConfigurations;
}
public void setBuildConfigurations(String conf) {
this.buildConfigurations = conf;
}
public void setConf(String conf) {
this.buildConfigurations = conf;
}
/**
* Get the main configuration where plugin are resolved
*
* @return a string representing the main configuration
*/
public String getMainConf() {
return mainConf;
}
/**
* Set the main configuration where plugin are resolved
*
* @param mainConf
* a string representing the main configuration
*/
public void setMainConf(String mainConf) {
this.mainConf = mainConf;
}
/**
* Get the configuration that may contain dependency on easyant-core. This configuration is used to check core
* compliance at resolve time. It should not affect the plugin classpath
*
* @return provided configuration
*/
public String getProvidedConf() {
return providedConf;
}
/**
* Set the configuration that may contain dependency on easyant-core. This configuration is used to check core
* compliance at resolve time. It should not affect the plugin classpath
*
* @return provided configuration
*/
public void setProvidedConf(String providedConf) {
this.providedConf = providedConf;
}
/**
* Can we skip the load of this module?
*
* return true if the module can't be skipped
*/
public boolean isMandatory() {
return mandatory;
}
/**
* Can we skip the load of this module?
*
* @param mandatory
* true if the module can't be skipped
*/
public void setMandatory(boolean mandatory) {
this.mandatory = mandatory;
}
public boolean isChanging() {
return changing;
}
public void setChanging(boolean changing) {
this.changing = changing;
}
}